home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / b / b.lha / B / src / bint / b1com.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-11-24  |  3.8 KB  |  184 lines
  1. /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  2.  
  3. /*
  4.   $Header: b1com.c,v 1.4 85/08/22 16:48:13 timo Exp $
  5. */
  6.  
  7. /************************************************************************/
  8. /* B compounds                                                          */
  9. /* plus Hows Funs and other odd types that don't fit anywhere else      */
  10. /*                                                                      */
  11. /* A compound is modelled as a sequence of len values, its fields.      */
  12. /*                                                                      */
  13. /************************************************************************/
  14.  
  15. #include "b.h"
  16. #include "b1obj.h"
  17. #include "b2nod.h"
  18.  
  19. /* NODES */
  20.  
  21. Visible typenode nodetype(v) parsetree v; {
  22.     return Is_parsetree(v) ? Nodetype(v) : Nonode;
  23. }
  24.  
  25. Hidden value
  26. mk_ptn(type, len) /* make parsetree node */
  27.     typenode type;
  28.     intlet len;
  29. {
  30.     parsetree v= (parsetree) grab_ptn((len<<8) | type);
  31.     *Branch(v, len)= *Branch(v, len+1)= NilTree;
  32.     return v;
  33. }
  34.  
  35. Visible parsetree
  36. node1(type)
  37.     typenode type;
  38. {
  39.     return mk_ptn(type, 0);
  40. }
  41.  
  42. Visible parsetree
  43. node2(type, a1)
  44.     typenode type; value a1;
  45. {
  46.     parsetree v= mk_ptn(type, 1); value *p= Ats(v);
  47.     *p++= a1;
  48.     return v;
  49. }
  50.  
  51. Visible parsetree
  52. node3(type, a1, a2)
  53.     typenode type; value a1, a2;
  54. {
  55.     parsetree v= mk_ptn(type, 2); value *p= Ats(v);
  56.     *p++= a1; *p++= a2;
  57.     return v;
  58. }
  59.  
  60. Visible parsetree
  61. node4(type, a1, a2, a3)
  62.     typenode type; value a1, a2, a3;
  63. {
  64.     parsetree v= mk_ptn(type, 3); value *p= Ats(v);
  65.     *p++= a1; *p++= a2; *p++= a3;
  66.     return v;
  67. }
  68.  
  69. Visible parsetree
  70. node5(type, a1, a2, a3, a4)
  71.     typenode type; value a1, a2, a3, a4;
  72. {
  73.     parsetree v= mk_ptn(type, 4); value *p= Ats(v);
  74.     *p++= a1; *p++= a2; *p++= a3; *p++= a4;
  75.     return v;
  76. }
  77.  
  78. Visible parsetree
  79. node6(type, a1, a2, a3, a4,a5)
  80.     typenode type; value a1, a2, a3, a4, a5;
  81. {
  82.     parsetree v= mk_ptn(type, 5); value *p= Ats(v);
  83.     *p++= a1; *p++= a2; *p++= a3; *p++= a4; *p++= a5;
  84.     return v;
  85. }
  86.  
  87. Visible parsetree
  88. node8(type, a1, a2, a3, a4, a5, a6, a7)
  89.     typenode type; value a1, a2, a3, a4, a5, a6, a7;
  90. {
  91.     parsetree v= mk_ptn(type, 7); value *p= Ats(v);
  92.     *p++= a1; *p++= a2; *p++= a3; *p++= a4; *p++= a5; *p++= a6; *p++= a7;
  93.     return v;
  94. }
  95.  
  96. Visible parsetree
  97. node9(type, a1, a2, a3, a4, a5, a6, a7, a8)
  98.     typenode type; value a1, a2, a3, a4, a5, a6, a7, a8;
  99. {
  100.     parsetree v= mk_ptn(type, 8); value *p= Ats(v);
  101.     *p++= a1; *p++= a2; *p++= a3; *p++= a4; *p++= a5; *p++= a6;
  102.     *p++= a7; *p++= a8;
  103.     return v;
  104. }
  105.  
  106. /* OTHER TYPES */
  107.  
  108. Visible loc
  109. mk_simploc(id, en)
  110.     basidf id; env en;
  111. {
  112.     loc l= grab_sim();
  113.     (*Ats(l))= copy(id); (*(Ats(l)+1))= (value) en;
  114.     return l;
  115. }
  116.  
  117. Visible loc
  118. mk_trimloc(R, B, C)
  119.     loc R; value B, C;
  120. {
  121.     loc l= grab_tri(); trimloc *ll= (trimloc *)Ats(l);
  122.     ll->R= copy(R); ll->B= copy(B); ll->C= copy(C);
  123.     return l;
  124. }
  125.  
  126. Visible loc
  127. mk_tbseloc(R, K)
  128.     loc R; value K;
  129. {
  130.     loc l= grab_tse(); tbseloc *ll= (tbseloc *)Ats(l);
  131.     ll->R= copy(R); ll->K= copy(K);
  132.     return l;
  133. }
  134.  
  135. Visible fun
  136. mk_fun(adic, pre, unit, filed)
  137.     literal adic; intlet pre; parsetree unit; bool filed;
  138. {
  139.     fun f= grab_fun(); funprd *ff= (funprd *)Ats(f);
  140.     ff->adic= adic; ff->pre= pre; ff->unit= unit;
  141.     ff->unparsed= Yes; ff->filed= filed;
  142.     ff->code= NilTree;
  143.     return f;
  144. }
  145.  
  146. Visible prd
  147. mk_prd(adic, pre, unit, filed)
  148.     literal adic; intlet pre; parsetree unit; bool filed;
  149. {
  150.     prd p= grab_prd(); funprd *pp= (funprd *)Ats(p);
  151.     pp->adic= adic; pp->pre= pre; pp->unit= unit;
  152.     pp->unparsed= Yes; pp->filed= filed;
  153.     pp->code= NilTree;
  154.     return p;
  155. }
  156.  
  157. Visible value
  158. mk_how(unit, filed)
  159.     parsetree unit; bool filed;
  160. {
  161.     value h= grab_how(); how *hh= (how *)Ats(h);
  162.     hh->unit= unit; hh->unparsed= Yes; hh->filed= filed;
  163.     hh->code= NilTree;
  164.     return h;
  165. }
  166.  
  167. Visible value
  168. mk_ref(rp)
  169.     parsetree rp;
  170. {
  171.     value r= grab_ref();
  172.     *Ats(r)= copy(rp);
  173.     return r;
  174. }
  175.  
  176. Visible value
  177. mk_per(v)
  178.     value v;
  179. {
  180.     value p= grab_per();
  181.     *Ats(p)= copy(v);
  182.     return p;
  183. }
  184.